home *** CD-ROM | disk | FTP | other *** search
/ TeX 1995 July / TeX CD-ROM July 1995 (Disc 1)(Walnut Creek)(1995).ISO / dviware / dvitovdu / unix / c / pktopx.c < prev    next >
C/C++ Source or Header  |  1990-10-01  |  11KB  |  555 lines
  1. /* This was originally pktopx in C by Tomas Rokicki */
  2.  
  3. /* 
  4.    This version converted for DVItoVDU and ported to BSD and System V UNIX by
  5.    some chaps at Kernel Technology up to September 1989.  Contact
  6.    mjh@uk.co.kernel (Mark J. Hewitt) with bug fixes etc.
  7.  
  8.    Involved were:    Mark J. Hewitt
  9.                Dave Dixon
  10.             Marc Hadley
  11. */
  12.  
  13. #include "def.h"
  14.  
  15. static char *sccsid[] = "@(#)pktopx.c    1.1";
  16.  
  17. #ifdef USG
  18. # include <sys/types.h>
  19. # include <sys/stat.h>            /* definitions needed for chmod(2) */
  20. #endif /* USG */
  21.  
  22. #define NAMELENGTH 80 
  23. #define TERMINALLINELENGTH 132 
  24. #define MAXDIV32 100 
  25. #define ONEFOURTH 1073741824 
  26.  
  27. #define INCR(a) (a++)
  28. #define DECR(a) (a--)
  29. #define ROUND(a) ((int)(a+0.5))
  30.  
  31. /* values for access(2) `amode' argument */
  32. #define FILE_EXISTS   00
  33. #define FILE_READABLE 04
  34.  
  35. /* values returned by openpxlfile() */
  36. #define PXL_FILE_EXISTS  1
  37. #define PXL_FILE_CREATED 0
  38.  
  39. typedef int integer;
  40. typedef unsigned char quarterword;
  41. typedef char  boolean;
  42. typedef quarterword eightbits;
  43. typedef FILE * bytefile;
  44. bytefile pxlfile;
  45. bytefile pkfile;
  46. char  pxlname[81], pkname[81];
  47. integer pxlloc, pkloc;
  48. integer magnification;
  49. integer designsize;
  50. integer checksum;
  51. integer hppp, vppp;
  52. /* integer i, j; */
  53. integer endofpacket;
  54. integer rasterpointer[128];
  55. integer sizes[128];
  56. integer offsets[128];
  57. integer tfmwidth[128];
  58. integer dynf;
  59. integer car;
  60. integer cheight, cwidth;
  61. integer wordwidth;
  62. integer horesc;
  63. integer packetlength;
  64. eightbits inputbyte;
  65. eightbits bitweight;
  66. integer row[101];
  67. integer word;
  68. integer wordweight;
  69. integer power[32];
  70. integer gpower[33];
  71. integer repeatcount;
  72. integer rowsleft;
  73. boolean turnon;
  74. integer hbit;
  75. integer count;
  76. integer rp;
  77. integer dirptr;
  78. integer flagbyte;
  79. integer haveext;
  80. integer lastext;
  81. int   gargc;
  82. char **gargv;
  83.  
  84. initialize ()
  85. {
  86.   integer i;
  87.   power[0] = 1;
  88.   for (i = 1; i <= 30; i++)
  89.     power[i] = power[i - 1] * 2;
  90.   power[31] = -ONEFOURTH - ONEFOURTH;
  91.   gpower[0] = 0;
  92.   for (i = 1; i <= 32; i++)
  93.     gpower[i] = gpower[i - 1] + power[
  94.     i - 1];
  95.   for (i = 0; i <= 127; i++)
  96.     rasterpointer[i] = 0;
  97. }
  98.  
  99. jumpout ()
  100. {
  101.   exit (1);
  102. }
  103.  
  104. openpxlfile ()
  105. {
  106.   if(access(pxlname, FILE_EXISTS) == 0 &&
  107.      access(pxlname, FILE_READABLE) == 0)
  108.       return PXL_FILE_EXISTS;
  109.   else if((pxlfile = fopen (pxlname, "w")) == NULL)
  110.   {
  111.       fprintf(stderr, "can't write PXL file %s\n", pxlname);
  112.       fflush(stderr);
  113.       exitprog(1);
  114.   }
  115.   pxlloc = 0;
  116.   return PXL_FILE_CREATED;
  117. }
  118.  
  119. void openpkfile ()
  120. {
  121.     if((pkfile = fopen (pkname, "r")) == NULL)
  122.     {
  123.     fprintf(stderr, "can't read PK file %s\n", pkname);
  124.     fflush(stderr);
  125.     exitprog(1);
  126.     }
  127.   pkloc = 0;
  128. }
  129.  
  130. pixelinteger (i)
  131. integer i;
  132. {
  133.   (void) putc ((char) ((i >> 24) & 255), pxlfile);
  134.   (void) putc ((char) ((i >> 16) & 255), pxlfile);
  135.   (void) putc ((char) ((i >> 8) & 255), pxlfile);
  136.   (void) putc ((char) (i & 255), pxlfile);
  137.   INCR (pxlloc);
  138. }
  139.  
  140. eightbits pkbyte ()
  141. {
  142.   INCR (pkloc);
  143.   return (getc (pkfile));
  144. }
  145.  
  146. integer get16 ()
  147. {
  148.   integer a;
  149.   a = pkbyte ();
  150.   return (a * 256 + pkbyte ());
  151. }
  152.  
  153. integer get32 ()
  154. {
  155.   integer a;
  156.   a = get16 ();
  157.   if (a > 32767)
  158.     a = a - 65536;
  159.   return (a * 65536 + get16 ());
  160. }
  161.  
  162. integer getnyb ()
  163. {
  164.   eightbits temp;
  165.   if (bitweight == 0)
  166.   {
  167.     inputbyte = pkbyte ();
  168.     bitweight = 16;
  169.   }
  170.   temp = inputbyte / bitweight;
  171.   inputbyte = inputbyte - temp * bitweight;
  172.   bitweight = bitweight / 16;
  173.   return (temp);
  174. }
  175.  
  176. boolean getbit ()
  177. {
  178.   boolean temp;
  179.   bitweight = bitweight / 2;
  180.   if (bitweight == 0)
  181.   {
  182.     inputbyte = pkbyte ();
  183.     bitweight = 128;
  184.   }
  185.   temp = inputbyte >= bitweight;
  186.   if (temp)
  187.     inputbyte = inputbyte - bitweight;
  188.   return (temp);
  189. }
  190.  
  191. integer pkpackednum ()
  192. {
  193.   integer i, j;
  194.   i = getnyb ();
  195.   if (i == 0)
  196.   {
  197.     do
  198.     {
  199.       j = getnyb ();
  200.       INCR (i);
  201.     } while (!(j != 0));
  202.     while (i > 0)
  203.     {
  204.       j = j * 16 + getnyb ();
  205.       DECR (i);
  206.     }
  207.     return (j - 15 + (13 - dynf) * 16 + dynf);
  208.   }
  209.   else
  210.     if (i <= dynf)
  211.       return (i);
  212.     else
  213.       if (i < 14)
  214.     return ((i - dynf - 1) * 16 + getnyb () + dynf + 1
  215.       );
  216.       else
  217.       {
  218.     if (i == 14)
  219.       repeatcount = pkpackednum ();
  220.     else
  221.       repeatcount = 1;
  222.     return (pkpackednum ());
  223.       }
  224. }
  225.  
  226. skipspecials ()
  227. {
  228.   integer i, j;
  229.   do
  230.   {
  231.     flagbyte = pkbyte ();
  232.     if (flagbyte >= 240)
  233.       switch (flagbyte)
  234.       {
  235.     case 240: 
  236.     case 241: 
  237.     case 242: 
  238.     case 243: 
  239.  
  240.       {
  241.         i = 0;
  242.         for (j = 240; j <= flagbyte; j++)
  243.           i = 256 * i + pkbyte ();
  244.         for (j = 1; j <= i; j++)
  245.           (void) pkbyte ();
  246.       }
  247.       break;
  248.     case 244: 
  249.       i = get32 ();
  250.       break;
  251.     case 245: 
  252.  
  253.       {;
  254.       }
  255.       break;
  256.     case 246: 
  257.  
  258.       {;
  259.       }
  260.       break;
  261.     case 247: 
  262.     case 248: 
  263.     case 249: 
  264.     case 250: 
  265.     case 251: 
  266.     case 252: 
  267.     case 253: 
  268.     case 254: 
  269.     case 255: 
  270.  
  271.       {
  272.         (void) printf (" Unexpected %d!\n", flagbyte);
  273.         jumpout ();
  274.       }
  275.       break;
  276.       }
  277.   } while (!((flagbyte < 240) || (flagbyte == 245)));
  278. }
  279.  
  280. dialog ()
  281. {
  282.   integer i;
  283.   if ((gargc < 2) || (gargc > 3))
  284.   {
  285.     (void) printf (" Usage: pktopx pkfile[.pk] [pxlfile[.nnnnpxl]]\n")
  286.       ;
  287.     jumpout ();
  288.   }
  289.   (void) strcpy (pkname, gargv[1]);
  290.   lastext = -1;
  291.   i = 0;
  292.   while (pkname[i] != 0)
  293.   {
  294.     if (pkname[i] == '.')
  295.       lastext = i;
  296.     else
  297.       if (pkname[i] == '/')
  298.     lastext = -1;
  299.     INCR (i);
  300.   }
  301.   if (lastext == -1)
  302.   {
  303.     (void) strcpy (pkname + i, ".pk");
  304.     lastext = i;
  305.   }
  306.   if (gargc == 3)
  307.   {
  308.     (void) strcpy (pxlname, gargv[2]);
  309.     haveext = TRUE;
  310.   }
  311.   else
  312.   {
  313.     (void) strcpy (pxlname, pkname);
  314.     haveext = FALSE;
  315.   }
  316. }
  317.  
  318. int   pktopx (argc, argv)
  319. int   argc;
  320. char *argv[];
  321. {
  322.   integer i, j;
  323.     
  324.   gargc = argc;
  325.   gargv = argv;
  326.   initialize ();
  327.   dialog ();
  328.   openpkfile ();
  329.   if (pkbyte () != 247)
  330.   {
  331.     (void) printf (" Bad pk file!  pre command missing.\n");
  332.     jumpout ();
  333.   }
  334.   if (pkbyte () != 89)
  335.   {
  336.     (void) printf (" Wrong version of packed file!.\n");
  337.     jumpout ();
  338.   }
  339.   j = pkbyte ();
  340.   for (i = 1; i <= j; i++)
  341.     hppp = pkbyte ();
  342.   designsize = get32 ();
  343.   checksum = get32 ();
  344.   hppp = get32 ();
  345.   vppp = get32 ();
  346.   if (hppp != vppp)
  347.     (void) printf ("Warning:  aspect ratio not 1:1!\n");
  348.   magnification = ROUND (hppp * 72.27 * 5 / 65536);
  349.   if (!haveext)
  350.   {
  351.     i = ROUND (hppp * 72.27 * 5 / 65536);
  352.     (void) sprintf (pxlname + lastext, ".%dpxl", i);
  353.   }
  354.   if(openpxlfile () == PXL_FILE_EXISTS)
  355.   {
  356.       (void) fclose(pkfile);
  357.       return;
  358.   }
  359.   pixelinteger (1001);
  360.   skipspecials ();
  361.   while (flagbyte != 245)
  362.   {
  363.     dynf = flagbyte / 16;
  364.     flagbyte = flagbyte % 16;
  365.     turnon = flagbyte >= 8;
  366.     if (turnon)
  367.       flagbyte = flagbyte - 8;
  368.     if (flagbyte == 7)
  369.     {
  370.       packetlength = get32 ();
  371.       car = get32 ();
  372.       endofpacket = packetlength + pkloc;
  373.       if ((car > 127) || (car < 0))
  374.     goto lab9997;
  375.       tfmwidth[car] = get32 ();
  376.       horesc = get32 ();
  377.       i = get32 ();
  378.       cwidth = get32 ();
  379.       cheight = get32 ();
  380.       if ((cwidth < 0) || (cheight < 0) || (cwidth > 65535) || (
  381.         cheight > 65535))
  382.     goto lab9997;
  383.       wordwidth = (cwidth + 31) / 32;
  384.       sizes[car] = cwidth * 65536 + cheight;
  385.       i = get32 ();
  386.       j = get32 ();
  387.       if (j < 0)
  388.     j = j + 65536;
  389.       offsets[car] = i * 65536 + j;
  390.     }
  391.     else
  392.       if (flagbyte > 3)
  393.       {
  394.     packetlength = (flagbyte - 4) * 65536 + get16 ();
  395.     car = pkbyte ();
  396.     endofpacket = packetlength + pkloc;
  397.     if (car > 127)
  398.       goto lab9997;
  399.     i = pkbyte ();
  400.     tfmwidth[car] = i * 65536 + get16 ();
  401.     horesc = get16 ();
  402.     cwidth = get16 ();
  403.     cheight = get16 ();
  404.     wordwidth = (cwidth + 31) / 32;
  405.     sizes[car] = cwidth * 65536 + cheight;
  406.     i = get16 ();
  407.     j = get16 ();
  408.     if (i > 32767)
  409.       i = i - 65536;
  410.     offsets[car] = i * 65536 + j;
  411.       }
  412.       else
  413.       {
  414.     packetlength = flagbyte * 256 + pkbyte ();
  415.     car = pkbyte ();
  416.     endofpacket = packetlength + pkloc;
  417.     if (car > 127)
  418.       goto lab9997;
  419.     i = pkbyte ();
  420.     tfmwidth[car] = i * 65536 + get16 ();
  421.     horesc = pkbyte ();
  422.     cwidth = pkbyte ();
  423.     cheight = pkbyte ();
  424.     wordwidth = (cwidth + 31) / 32;
  425.     sizes[car] = cwidth * 65536 + cheight;
  426.     i = pkbyte ();
  427.     j = pkbyte ();
  428.     if (i > 127)
  429.       i = i - 256;
  430.     if (j > 127)
  431.       j = j + 255 * 256;
  432.     offsets[car] = i * 65536 + j;
  433.       }
  434.     if (rasterpointer[car] != 0)
  435.     {
  436.       (void) printf (" Second time this character used!\n");
  437.       jumpout ();
  438.     }
  439.     rasterpointer[car] = pxlloc;
  440.     bitweight = 0;
  441.     if (dynf == 14)
  442.     {
  443.       bitweight = 0;
  444.       for (i = 1; i <= cheight; i++)
  445.       {
  446.     word = 0;
  447.     wordweight = 31;
  448.     for (j = 1; j <= cwidth; j++)
  449.     {
  450.       if (getbit ())
  451.         word = word + power[wordweight];
  452.       wordweight = wordweight - 1;
  453.       if (wordweight == -1)
  454.       {
  455.         pixelinteger (word);
  456.         word = 0;
  457.         wordweight = 31;
  458.       }
  459.     }
  460.     if (wordweight < 31)
  461.       pixelinteger (word);
  462.       }
  463.     }
  464.     else
  465.     {
  466.       rowsleft = cheight;
  467.       hbit = cwidth;
  468.       repeatcount = 0;
  469.       wordweight = 32;
  470.       word = 0;
  471.       rp = 1;
  472.       while (rowsleft > 0)
  473.       {
  474.     count = pkpackednum ();
  475.     while (count > 0)
  476.     {
  477.       if ((count < wordweight) && (count < hbit))
  478.       {
  479.         if (turnon)
  480.           word = word + gpower[wordweight] - gpower
  481.         [wordweight - count];
  482.         hbit = hbit - count;
  483.         wordweight = wordweight - count;
  484.         count = 0;
  485.       }
  486.       else
  487.         if ((count >= hbit) && (hbit <= wordweight))
  488.         {
  489.           if (turnon)
  490.         word = word + gpower[wordweight] - gpower
  491.           [wordweight - hbit];
  492.           row[rp] = word;
  493.           for (i = 0; i <= repeatcount; i++)
  494.         for (j = 1; j <=
  495.             wordwidth; j++)
  496.           pixelinteger (row[j]);
  497.           rowsleft = rowsleft - repeatcount - 1;
  498.           repeatcount = 0;
  499.           rp = 1;
  500.           word = 0;
  501.           wordweight = 32;
  502.           count = count - hbit;
  503.           hbit = cwidth;
  504.         }
  505.         else
  506.         {
  507.           if (turnon)
  508.         word = word + gpower[wordweight];
  509.           row[rp] = word;
  510.           rp = rp + 1;
  511.           word = 0;
  512.           count = count - wordweight;
  513.           hbit = hbit - wordweight;
  514.           wordweight = 32;
  515.         }
  516.     }
  517.     turnon = !turnon;
  518.       }
  519.       if ((rowsleft != 0) || (hbit != cwidth))
  520.       {
  521.     (void) printf (" Bad pk file---more bits than required!\n");
  522.     jumpout ();
  523.       }
  524.     }
  525.     if (endofpacket != pkloc)
  526.     {
  527.       (void) printf (" Bad pk file!  Bad packet length.\n");
  528.       jumpout ();
  529.     }
  530.     goto lab9998;
  531. lab9997: while (pkloc != endofpacket)
  532.       i = pkbyte ();
  533.     (void) printf ("Character %d out of range!\n", car);
  534. lab9998: skipspecials ();
  535.   }
  536.   while (!feof (pkfile))
  537.     i = pkbyte ();
  538.   DECR (pkloc);
  539.   dirptr = pxlloc;
  540.   for (car = 0; car <= 127; car++)
  541.   {
  542.     pixelinteger (sizes[car]);
  543.     pixelinteger (offsets[car]);
  544.     pixelinteger (rasterpointer[car]);
  545.     pixelinteger (tfmwidth[car]);
  546.   }
  547.   pixelinteger (checksum);
  548.   pixelinteger (magnification);
  549.   pixelinteger (designsize);
  550.   pixelinteger (dirptr);
  551.   pixelinteger (1001);
  552.   (void) fclose (pxlfile);
  553.   (void) fclose (pkfile);
  554. }
  555.